const express = require('express');
const router = express.Router();
const md5=require('md5')
const Notice =require('../models/Notice')
const Competition=require('../models/Competition')
const jwt=require('jsonwebtoken')
const path = require('path');
const authenticateToken =require('../middlewares/authenticateToken');
const mongoose=require('mongoose')
const multer = require('multer');

const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, 'uploads/competition/');
  },
  filename: function (req, file, cb) {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, req.user.id + '-' + uniqueSuffix + path.extname(file.originalname));
  }
});

const upload = multer({ 
  storage: storage,
  limits: {
    fileSize: 2 * 1024 * 1024 // 2MB限制
  },
  fileFilter: function (req, file, cb) {
    if (file.mimetype.startsWith('image/')) {
      cb(null, true);
    } else {
      cb(new Error('只允许上传图片文件'), false);
    }
  }
});

//创建公告2
router.post('/super/createNotice', authenticateToken, async (req, res) => {
  try {
    const creatorId = req.user.id;
    const { title, content = '', tag = '',object='' } = req.body;

    // 创建新公告
    const newNotice = new Notice({
      creatorId: creatorId, 
      title,
      content,
      tag,
      object
    });
    await newNotice.save();

    // 返回数据（同步修改字段名，与模型/存储一致）
    res.json({
      code: '0000',
      msg: '公告创建成功',
      data: {
        id: newNotice._id,
        creatorId: newNotice.creatorId, 
        title: newNotice.title,
        content: newNotice.content,
        tag: newNotice.tag,
        object: newNotice.object,
        publishTime: newNotice.publishTime
      }
    });
  } catch (err) {
    // 捕获异常，返回明确的错误信息
    console.error('创建公告失败：', err); // 打印错误详情，便于定位（比如数据库字段缺失）
    return res.json({
      code: '500',
      msg: '服务异常：' + err.message, // 把具体错误信息返回给前端（调试阶段用）
      data: {}
    });
  }
});

//修改公告
router.patch('/super/updateNotice', authenticateToken, async (req, res) => {
  try {
    // 1. 从请求体提取公告ID和修改字段（核心：id放在body中）
    const { id: noticeId, title, content, tag, object } = req.body;

    // 2. 校验：必须传公告ID
    if (!noticeId) {
      return res.json({
        code: '400',
        msg: '请传入公告ID（id字段）',
        data: {}
      });
    }

    // 3. 校验ID格式有效性
    if (!mongoose.Types.ObjectId.isValid(noticeId)) {
      return res.json({
        code: '400',
        msg: '公告ID格式错误',
        data: {}
      });
    }

    // 4. 查询公告是否存在
    const notice = await Notice.findById(noticeId);
    if (!notice) {
      return res.json({
        code: '404',
        msg: '公告不存在或已被删除',
        data: {}
      });
    }

    // 5. 局部更新：只修改前端传递的非空字段
    if (title !== undefined) notice.title = title;
    if (content !== undefined) notice.content = content;
    if (tag !== undefined) notice.tag = tag;
    if (object !== undefined) notice.object = object;

    await notice.save();

    // 6. 返回更新后的数据（与创建接口格式一致）
    res.json({
      code: '0000',
      msg: '公告修改成功',
      data: {
        id: notice._id,
        creatorId: notice.creatorId, // 不允许修改，保留原创建者
        title: notice.title,
        content: notice.content,
        tag: notice.tag,
        object: notice.object,
        publishTime: notice.publishTime // 不允许修改，保留原发布时间
      }
    });
  } catch (err) {
    console.error('修改公告失败：', err);
    return res.json({
      code: '500',
      msg: '服务异常：' + err.message,
      data: {}
    });
  }
});

//删除公告
router.delete('/super/deleteNotice', authenticateToken, async (req, res) => {
  try {
    // 1. 从请求体提取公告ID（核心：id放在body中）
    const { id: noticeId } = req.body;

    // 2. 校验：必须传公告ID
    if (!noticeId) {
      return res.json({
        code: '400',
        msg: '请传入公告ID（id字段）',
        data: {}
      });
    }

    // 3. 校验ID格式有效性
    if (!mongoose.Types.ObjectId.isValid(noticeId)) {
      return res.json({
        code: '400',
        msg: '公告ID格式错误',
        data: {}
      });
    }

    // 4. 查询并删除公告（原子操作，返回删除前的数据）
    const deletedNotice = await Notice.findOneAndDelete({ _id: noticeId });
    if (!deletedNotice) {
      return res.json({
        code: '404',
        msg: '公告不存在或已被删除',
        data: {}
      });
    }

    // 5. 返回删除确认信息
    res.json({
      code: '0000',
      msg: '公告删除成功',
      data: {
        deletedId: deletedNotice._id, // 被删除公告的ID（便于前端同步）
        title: deletedNotice.title    // 被删除公告的标题（增强交互体验）
      }
    });
  } catch (err) {
    console.error('删除公告失败：', err);
    return res.json({
      code: '500',
      //msg: '服务异常：' + err.message,
      data: {}
    });
  }
});


//获取所有公告列表
router.get('/super/getNoticeList', authenticateToken, async (req, res) => {
  try {
    // 接收前端传递的平台参数（object）
    const { object } = req.query;
    // 构造查询条件：有object则按平台筛选，否则查询全部
    const queryCondition = object ? { object } : {};

    // 数据库查询（带平台筛选）
    const noticeList = await Notice.find(queryCondition)
      .populate({
        path: 'creatorId', // 关联创建人（Admin模型）
        model: 'Admin',
        select: 'nickname' // 仅获取昵称
      })
      .sort({ publishTime: -1 }) // 最新公告在前
      .select('-__v'); // 排除MongoDB默认的__v字段

    // 查询总条数（带平台筛选）
    const total = await Notice.countDocuments(queryCondition);

    // 格式化响应数据
    const formattedList = noticeList.map(notice => ({
      id: notice._id.toString(), // 公告ID（字符串格式）
      title: notice.title, // 公告标题
      content: notice.content || '', // 公告内容（空内容兜底）
      tag: notice.tag || '无标签', // 标签（无标签兜底）
      object: notice.object, // 平台字段
      publishTime: notice.publishTime, // 发布时间
      creatorName: notice.creatorId?.nickname || '未知' // 创建人昵称（关联兜底）
    }));

    // 统一响应格式
    res.json({
      code: '0000',
      msg: '获取公告列表成功',
      data: {
        list: formattedList, // 公告列表
        total // 总条数
      }
    });
  } catch (err) {
    // 异常处理
    console.error('获取公告列表失败：', err);
    res.json({
      code: '500',
      msg: '服务异常：' + err.message,
      data: {
        list: [],
        total: 0
      }
    });
  }
});


//创建征文
router.post('/super/createCompetition', authenticateToken, upload.single('cover'), async (req, res) => {
  try {
    const creatorId = req.user.id;
    // 直接获取前端传递的字符串日期（无需解析）
    const { title, theme, description, startDate, endDate, status, platform, awards, rules } = req.body;

    // 简单校验：确保日期字符串不为空（模型已做必填校验，此处可选增强）
    if (!startDate || !endDate) {
      return res.json({
        code: '400',
        msg: '请选择完整的比赛时间',
        data: {}
      });
    }

    const coverPath = `http://localhost:3001/uploads/competition/${req.file.filename}`;

    // 创建新征文：直接传入字符串日期
    const newCompetition = new Competition({
      creatorId: creatorId, 
      title,
      theme,
      description,
      startDate: startDate, // 字符串日期直接赋值
      endDate: endDate,     // 字符串日期直接赋值
      status: status || '未开始',
      platform,
      awards,
      rules,
      cover: coverPath
    });
    await newCompetition.save();

    // 返回成功响应
    res.json({
      code: '0000',
      msg: '征文创建成功',
      data: { 
        id: newCompetition._id, 
        title: newCompetition.title,
        startDate: newCompetition.startDate, // 返回字符串日期
        endDate: newCompetition.endDate     // 返回字符串日期
      }
    });
  } catch (err) {
    console.error('创建征文失败：', err);
    return res.json({
      code: '500',
      msg: '服务异常：' + err.message,
      data: {}
    });
  }
});


//获取所有征文列表
router.get('/super/getCompetitionList', authenticateToken, async (req, res) => {
  try {
    // 1. 接收前端参数：分页参数（默认第1页，每页10条）+ 状态筛选（可选）
    const { 
      page = 1, 
      limit = 10, 
      status = '' // 可选筛选：未开始/进行中/已结束
    } = req.query;

    // 2. 构造查询条件：状态有值则筛选，无值则查全部
    const queryCondition = status ? { status } : {};

    // 3. 数据库查询：关联创建人昵称 + 分页 + 排序
    const skip = (page - 1) * Number(limit); // 计算跳过条数
    const competitionList = await Competition.find(queryCondition)
      .populate({
        path: 'creatorId', // 关联Admin模型获取创建人信息
        model: 'Admin',
        select: 'nickname' // 仅返回昵称，避免敏感信息
      })
      .sort({ startDate: -1 }) // 按开始时间倒序（最新征文在前）
      .skip(skip)
      .limit(Number(limit))
      .select('-__v'); // 排除MongoDB默认的__v字段

    // 4. 查询总条数（用于分页计算）
    const total = await Competition.countDocuments(queryCondition);

    // 5. 格式化响应数据（统一字段格式，空值兜底）
    const formattedList = competitionList.map(competition => ({
      id: competition._id.toString(), // 征文ID（字符串格式，便于前端存储）
      title: competition.title,
      theme: competition.theme || '无主题',
      description: competition.description || '无描述',
      startDate: competition.startDate, // 字符串格式日期（与模型一致）
      endDate: competition.endDate,
      status: competition.status, // 未开始/进行中/已结束
      creatorId: competition.creatorId?._id.toString() || '',
      creatorName: competition.creatorId?.nickname || '未知创建人',
      cover: competition.cover || '', // 封面URL（空则无封面）
      platform: competition.platform || '无',
      awards: competition.awards || '无',
      rules: competition.rules || '无'
    }));

    // 6. 统一响应格式
    res.json({
      code: '0000',
      msg: '获取征文列表成功',
      data: {
        list: formattedList,
        pagination: {
          total: total, // 总条数
          page: Number(page), // 当前页码
          limit: Number(limit), // 每页条数
          totalPages: Math.ceil(total / Number(limit)) // 总页数（便于前端分页控件）
        }
      }
    });
  } catch (err) {
    console.error('获取征文列表失败：', err);
    res.json({
      code: '500',
      msg: '服务异常：' + err.message,
      data: {
        list: [],
        pagination: { total: 0, page: 1, limit: 10, totalPages: 0 }
      }
    });
  }
});


//获取单个征文详情
router.get('/super/getCompetitionInfo', authenticateToken, async (req, res) => {
  try {
    // 1. 提取请求参数：征文ID（必传）
    const { id: competitionId } = req.query;

    // 2. 校验：必须传递征文ID
    if (!competitionId) {
      return res.json({
        code: '400',
        msg: '请传入征文ID（id字段）',
        data: {}
      });
    }

    // 3. 校验ID格式有效性
    if (!mongoose.Types.ObjectId.isValid(competitionId)) {
      return res.json({
        code: '400',
        msg: '征文ID格式错误',
        data: {}
      });
    }

    // 4. 查询征文详情（关联创建人昵称）
    const competitionDetail = await Competition.findById(competitionId)
      .populate({
        path: 'creatorId',
        model: 'Admin',
        select: 'nickname' // 仅返回创建人昵称
      })
      .select('-__v'); // 排除MongoDB默认的__v字段

    // 5. 处理查询结果：征文不存在则返回404
    if (!competitionDetail) {
      return res.json({
        code: '404',
        msg: '征文不存在或已被删除',
        data: {}
      });
    }

    // 6. 格式化响应数据（空值兜底）
    const formattedDetail = {
      id: competitionDetail._id.toString(),
      title: competitionDetail.title,
      theme: competitionDetail.theme || '无主题',
      description: competitionDetail.description || '无描述',
      startDate: competitionDetail.startDate,
      endDate: competitionDetail.endDate,
      status: competitionDetail.status,
      creatorId: competitionDetail.creatorId?._id.toString() || '',
      creatorName: competitionDetail.creatorId?.nickname || '未知创建人',
      cover: competitionDetail.cover || '',
      platform: competitionDetail.platform || '无',
      awards: competitionDetail.awards || '无',
      rules: competitionDetail.rules || '无',
    };

    // 7. 统一响应格式
    res.json({
      code: '0000',
      msg: '获取征文详情成功',
      data: formattedDetail
    });
  } catch (err) {
    console.error('获取征文详情失败：', err);
    res.json({
      code: '500',
      msg: '服务异常：' + err.message,
      data: {}
    });
  }
});


//修改征文
router.patch('/super/updateCompetition', authenticateToken, upload.single('cover'), async (req, res) => {
  try {
    // 1. 提取请求参数：征文ID（必传）+ 其他待修改字段 + 封面文件
    const { id: competitionId, title, theme, description, startDate, endDate, status, platform, awards, rules } = req.body;
    const newCoverPath = req.file?.path; // 新封面路径（有上传则更新，无则保留原封面）

    // 2. 校验：必须传递征文ID
    if (!competitionId) {
      return res.json({
        code: '400',
        msg: '请传入征文ID（id字段）',
        data: {}
      });
    }

    // 3. 校验ID格式有效性
    if (!mongoose.Types.ObjectId.isValid(competitionId)) {
      return res.json({
        code: '400',
        msg: '征文ID格式错误',
        data: {}
      });
    }

    // 4. 查询征文是否存在（不存在则返回404）
    const competition = await Competition.findById(competitionId);
    if (!competition) {
      return res.json({
        code: '404',
        msg: '征文不存在或已被删除',
        data: {}
      });
    }

    // 5. 局部更新：仅修改前端传递的非空字段
    if (title !== undefined) competition.title = title;
    if (theme !== undefined) competition.theme = theme;
    if (description !== undefined) competition.description = description;
    if (startDate !== undefined) competition.startDate = startDate; // 字符串日期直接赋值
    if (endDate !== undefined) competition.endDate = endDate;
    if (status !== undefined) {
      // 校验状态值是否符合enum规则
      const validStatus = ['未开始', '进行中', '已结束'];
      if (!validStatus.includes(status)) {
        return res.json({
          code: '400',
          msg: '状态值无效，仅支持：未开始/进行中/已结束',
          data: {}
        });
      }
      competition.status = status;
    }
    if (platform !== undefined) competition.platform = platform;
    if (awards !== undefined) competition.awards = awards;
    if (rules !== undefined) competition.rules = rules;
    if (newCoverPath) competition.cover = newCoverPath; // 有新封面则更新路径

    // 6. 保存修改到数据库
    await competition.save();

    // 7. 格式化并返回更新后的数据
    res.json({
      code: '0000',
      msg: '征文修改成功',
      data: {
        id: competition._id.toString(),
        title: competition.title,
        theme: competition.theme,
        startDate: competition.startDate,
        endDate: competition.endDate,
        status: competition.status,
        cover: competition.cover, // 返回最新封面路径
        updatedTime: new Date().format('yyyy-MM-dd HH:mm:ss') // 新增更新时间（便于前端同步）
      }
    });
  } catch (err) {
    console.error('修改征文失败：', err);
    res.json({
      code: '500',
      msg: '服务异常：' + err.message,
      data: {}
    });
  }
});


//删除征文
router.delete('/super/deleteCompetition', authenticateToken, async (req, res) => {
  try {
    // 1. 提取请求参数：征文ID（必传）
    const { id: competitionId } = req.body;

    // 2. 校验：必须传递征文ID
    if (!competitionId) {
      return res.json({
        code: '400',
        msg: '请传入征文ID（id字段）',
        data: {}
      });
    }

    // 3. 校验ID格式有效性
    if (!mongoose.Types.ObjectId.isValid(competitionId)) {
      return res.json({
        code: '400',
        msg: '征文ID格式错误',
        data: {}
      });
    }

    // 4. 查询并删除征文（原子操作，返回删除前的数据）
    const deletedCompetition = await Competition.findOneAndDelete({ _id: competitionId });
    if (!deletedCompetition) {
      return res.json({
        code: '404',
        msg: '征文不存在或已被删除',
        data: {}
      });
    }

    // 5. 可选：删除服务器上的封面文件（需引入fs模块）
    const fs = require('fs');
    if (deletedCompetition.cover) {
      // 检查文件是否存在，存在则删除
      fs.existsSync(deletedCompetition.cover) && fs.unlinkSync(deletedCompetition.cover);
    }

    // 6. 返回删除确认信息（便于前端同步列表）
    res.json({
      code: '0000',
      msg: '征文删除成功',
      data: {
        deletedId: deletedCompetition._id.toString(), // 被删除征文ID
        deletedTitle: deletedCompetition.title // 被删除征文标题（增强交互体验）
      }
    });
  } catch (err) {
    console.error('删除征文失败：', err);
    res.json({
      code: '500',
      msg: '服务异常：' + err.message,
      data: {}
    });
  }
});


// 切换征文比赛状态接口
router.put('/super/updateCompetitionStatus', authenticateToken, async (req, res) => {
  try {
    // 1. 接收请求参数（JSON格式）
    const { competitionId, newStatus } = req.body;

    // 2. 必传参数校验
    if (!competitionId || !newStatus) {
      return res.json({
        code: '400',
        msg: '请传入征文ID（competitionId）和新状态（newStatus）',
        data: {}
      });
    }

    // 3. 征文ID格式校验
    if (!mongoose.Types.ObjectId.isValid(competitionId)) {
      return res.json({
        code: '400',
        msg: '征文ID格式错误',
        data: {}
      });
    }

    // 4. 新状态合法性校验（必须在枚举值内）
    const validStatus = ['未开始', '进行中', '已结束'];
    if (!validStatus.includes(newStatus)) {
      return res.json({
        code: '400',
        msg: `新状态必须是以下值之一：${validStatus.join('、')}`,
        data: {}
      });
    }

    // 5. 查询征文是否存在
    const competition = await Competition.findById(competitionId);
    if (!competition) {
      return res.json({
        code: '404',
        msg: '征文不存在或已被删除',
        data: {}
      });
    }

    // 6. 状态无变化时直接返回成功
    if (competition.status === newStatus) {
      return res.json({
        code: '0000',
        msg: `征文状态已为${newStatus}，无需重复修改`,
        data: {
          id: competition._id.toString(),
          title: competition.title,
          status: competition.status
        }
      });
    }

    // 7. 更新状态并保存
    competition.status = newStatus;
    const updatedCompetition = await competition.save();

    // 8. 格式化响应数据
    const formattedData = {
      id: updatedCompetition._id.toString(),
      title: updatedCompetition.title,
      status: updatedCompetition.status,
      updateTime: new Date().toLocaleString() // 新增更新时间字段
    };

    // 9. 统一响应格式
    res.json({
      code: '0000',
      msg: `征文状态已成功更新为${newStatus}`,
      data: formattedData
    });

  } catch (err) {
    console.error('更新征文状态失败：', err);
    res.json({
      code: '500',
      msg: '服务异常：' + err.message,
      data: {}
    });
  }
});

module.exports = router;